सी में अनंत लूप

अनंत लूप क्या है?

एक अनंत लूप एक लूपिंग निर्माण है जो लूप को समाप्त नहीं करता है और लूप को हमेशा के लिए निष्पादित करता है। इसे अनिश्चितकालीन लूप या एक अंतहीन लूप भी कहा जाता है। यह या तो एक निरंतर आउटपुट या कोई आउटपुट पैदा करता है।

जब एक अनंत लूप का उपयोग करने के लिए

एक अनंत लूप उन अनुप्रयोगों के लिए उपयोगी होता है जो उपयोगकर्ता इनपुट को स्वीकार करते हैं और आउटपुट को लगातार उत्पन्न करते हैं जब तक कि उपयोगकर्ता मैन्युअल रूप से एप्लिकेशन से बाहर नहीं निकलता है। निम्नलिखित स्थितियों में, इस प्रकार के लूप का उपयोग किया जा सकता है: सभी ऑपरेटिंग सिस्टम एक अनंत लूप में चलते हैं क्योंकि यह कुछ कार्य करने के बाद मौजूद नहीं है। यह केवल एक अनंत लूप से निकलता है जब उपयोगकर्ता मैन्युअल रूप से सिस्टम को बंद कर देता है। सभी सर्वर एक अनंत लूप में चलते हैं क्योंकि सर्वर सभी क्लाइंट अनुरोधों पर प्रतिक्रिया करता है। यह एक अनिश्चित लूप से निकलता है जब प्रशासक मैन्युअल रूप से सर्वर को बंद कर देता है। सभी खेल भी एक अनंत लूप में चलते हैं। जब तक उपयोगकर्ता गेम से बाहर नहीं निकलता, तब तक गेम उपयोगकर्ता के अनुरोधों को स्वीकार करेगा। हम विभिन्न लूप संरचनाओं के माध्यम से एक अनंत लूप बना सकते हैं। निम्नलिखित लूप संरचनाएं हैं जिनके माध्यम से हम अनंत लूप को परिभाषित करेंगे: पाश के लिए जबकि पाश डू-वियस लूप बयान पर जाना सी मैक्रोज़

पाश के लिए

आइए 'लूप के लिए अनंत' देखें। लूप के लिए अनंत के लिए निम्नलिखित परिभाषा है:

kurftae(; ;)
{
// Sarir ka kurftae kuMdlai.
}

जैसा कि हम जानते हैं कि 'लूप' के सभी भाग वैकल्पिक हैं, और उपरोक्त लूप के लिए, हमने किसी भी स्थिति का उल्लेख नहीं किया है; तो, यह लूप अनंत समय निष्पादित करेगा।

उदाहरण

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
kurftae(;;)
{
mauDznama("namastae jaavaatvaEMT");
}
naivaZtanama 0;
}

उपरोक्त कोड में, हम 'लूप अनंत समय' के लिए 'चलाते हैं, इसलिए "हैलो जावेटपॉइंट" को असीम रूप से प्रदर्शित किया जाएगा।

जबकि पाश

अब, हम देखेंगे कि कैसे लूप का उपयोग करके अनंत लूप बनाया जाए। लूप जबकि अनंत के लिए निम्नलिखित परिभाषा है:

yaavaD(1)
{
// Sarir ka kuMdlai..
}

उपरोक्त में लूप में, हम लूप की स्थिति के अंदर '1' डालते हैं। जैसा कि हम जानते हैं कि कोई भी गैर-शून्य पूर्णांक सही स्थिति का प्रतिनिधित्व करता है जबकि '0' झूठी स्थिति का प्रतिनिधित्व करता है।

आइए एक सरल उदाहरण देखें।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
paunaZ maIM=0;
yaavaD(1)
{
maIM++;
mauDznama("i hI :%paunaZ",maIM);
}
naivaZtanama 0;
}

उपरोक्त कोड में, हमने कुछ समय के लिए परिभाषित किया है, जो अनंत समय चलाता है क्योंकि इसमें कोई स्थिति नहीं होती है। 'I' के मान को अनंत संख्या में अद्यतन किया जाएगा।

करो..जब लूप

अनंत लूप बनाने के लिए लूप का उपयोग भी किया जा सकता है। निम्नलिखित अनंत बनाने के लिए वाक्यविन्यास है।

kraetau
{
// Sarir ka kuMdlai..
}yaavaD(1);

उपरोक्त kraetau..hely लूप अनंत स्थिति का प्रतिनिधित्व करता है क्योंकि हम लूप स्थिति के अंदर '1' मान प्रदान करते हैं। जैसा कि हम पहले से ही जानते हैं कि गैर-शून्य पूर्णांक सही स्थिति का प्रतिनिधित्व करता है, इसलिए यह लूप अनंत समय चलाएगा।

गोटो स्टेटमेंट

हम अनंत लूप को परिभाषित करने के लिए गोटो स्टेटमेंट का भी उपयोग कर सकते हैं।

AnaMtaRlaupa;
// Sarir kYana.
gacCtau AnaMtaRlaupa;

AnaMtaRlaupa;
// Sarir kYana.
gacCtau AnaMtaRlaupa;

उपरोक्त कोड में, गोटो स्टेटमेंट अनंत लूप में नियंत्रण को स्थानांतरित करता है।

मैक्रो

हम एक मैक्रो स्थिरांक की मदद से अनंत लूप भी बना सकते हैं। आइए एक उदाहरण के माध्यम से समझें।

#samaahitaF <PsaTidiAayaAae.Pca>
#pariBaacCsai AnaMta kurftae(;;)
paunaZ mauqyaF()
{

AnaMta
{
mauDznama("namastae");
}

naivaZtanama 0;
}

maeM Ufpar kaed, hma paasaRhaenaa pariBaaSaita P maIkzae naama jaIsaa 'AnaMta', AaIr Esaka kimata hI 'kurftae(;;)'. jabaRkBaiRBai SabD 'AnaMta' AataaRhI maeM P kayaZkzma taba yah EcCa haenaa jagahRlaeRlai saaYa P 'kurftae(;;)'.

<Baagaakar>उपरोक्त कोड में, हमने एक मैक्रो को 'अनंत' के रूप में नामित किया है, और इसका मूल्य '(;;)' के लिए है। जब भी 'अनंत' शब्द एक कार्यक्रम में आता है, तो इसे '(;;)' के साथ बदल दिया जाएगा।Baagaakar>

अब तक, हमने एक अनंत लूप को परिभाषित करने के विभिन्न तरीके देखे हैं। हालांकि, हमें अनंत लूप से बाहर आने के लिए कुछ दृष्टिकोण की आवश्यकता है। अनंत लूप से बाहर आने के लिए, हम ब्रेक स्टेटमेंट का उपयोग कर सकते हैं।

आइए एक उदाहरण के माध्यम से समझें।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
AxarF caaIoari;
yaavaD(1)
{
caaIoari=Axar_paVtau_1();
yaDi(caaIoari=='Pna')
{
vairmatau;
}
mauDznama("namastae");
}
naivaZtanama 0;
}

उपरोक्त कोड में, हमने लूप को परिभाषित किया है, जो तब तक अनंत संख्या में निष्पादित करेगा जब तक हम कुंजी 'एन' को दबाते हैं। हमने जबकि लूप के अंदर 'अगर' बयान जोड़ा है। 'IF' स्टेटमेंट में ब्रेक कीवर्ड होता है, और ब्रेक कीवर्ड लूप से नियंत्रण लाता है।

अनैतिक अनंत छोर

कभी -कभी स्थिति उत्पन्न होती है जहां कोड में बग के कारण अनजाने अनंत छोर होते हैं। यदि हम शुरुआती हैं, तो उन्हें ट्रेस करना बहुत मुश्किल हो जाता है। नीचे एक अनजाने अनंत लूप का पता लगाने के लिए कुछ उपाय दिए गए हैं: हमें अर्धविरामों की सावधानीपूर्वक जांच करनी चाहिए। कभी -कभी हम अर्धविराम को गलत जगह पर डालते हैं, जो अनंत लूप की ओर जाता है।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
paunaZ maIM=1;
yaavaD(maIM<=10);
{
mauDznama("%paunaZ", maIM);
maIM++;
}
naivaZtanama 0;
}

उपरोक्त कोड में, हमने अर्धविराम को लूप की स्थिति के बाद रखा जो अनंत लूप की ओर जाता है। इस अर्धविराम के कारण, जबकि लूप का आंतरिक शरीर निष्पादित नहीं करेगा। हमें तार्किक स्थितियों की सावधानीपूर्वक जांच करनी चाहिए। कभी -कभी गलती से, हम एक संबंधपरक ऑपरेटर (= =) के बजाय असाइनमेंट ऑपरेटर (=) को रखते हैं।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
AxarF caaIoari='Pna';
yaavaD(caaIoari='la')
{
mauDznama("namastae");
}
naivaZtanama 0;
}

उपरोक्त कोड में, हम असाइनमेंट ऑपरेटर (ch = 'y') का उपयोग करते हैं, जो लूप अनंत संख्या के निष्पादन की ओर जाता है। हम गलत लूप स्थिति का उपयोग करते हैं जिसके कारण लूप को अनिश्चित काल तक निष्पादित किया जाता है।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
kurftae(paunaZ maIM=1;maIM>=1;maIM++)
{
mauDznama("namastae");
}
naivaZtanama 0;
}

उपरोक्त कोड 'लूप' के लिए अनंत संख्या को निष्पादित करेगा। जैसा कि हमने स्थिति (i> = 1) डाल दी, जो हमेशा हर स्थिति के लिए सच होगी, इसका मतलब है कि "हैलो" असीम रूप से मुद्रित किया जाएगा। हमें सावधान रहना चाहिए जब हम नेस्टेड लूप में ब्रेक कीवर्ड का उपयोग कर रहे हैं क्योंकि यह निकटतम लूप के निष्पादन को समाप्त कर देगा, न कि पूरे लूप के।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
yaavaD(1)
{
kurftae(paunaZ maIM=1;maIM<=10;maIM++)
{
yaDi(maIM%2==0)
{
vairmatau;
}
}
}
naivaZtanama 0;
}

उपरोक्त कोड में, जबकि लूप को अनंत संख्या में निष्पादित किया जाएगा क्योंकि हम एक आंतरिक लूप में ब्रेक कीवर्ड का उपयोग करते हैं। यह ब्रेक कीवर्ड आंतरिक लूप से नियंत्रण को बाहर लाएगा, बाहरी लूप से नहीं। जब हम लूप के अंदर फ्लोटिंग-पॉइंट वैल्यू का उपयोग कर रहे हों तो हमें बहुत सावधान रहना चाहिए क्योंकि हम फ्लोटिंग-पॉइंट त्रुटियों को कम नहीं कर सकते हैं।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
ApaunaZ PKsa = 3.0;
yaavaD (PKsa != 4.0) {
mauDznama("x = %ApaunaZ\n", PKsa);
PKsa += 0.1;
}
naivaZtanama 0;
}

उपरोक्त कोड में, लूप अनंत समय चलाएगा क्योंकि कंप्यूटर वास्तविक मूल्य के रूप में फ्लोटिंग-पॉइंट मूल्य का प्रतिनिधित्व करता है। कंप्यूटर 4.0 के मूल्य को 3.999999 या 4.000001 के रूप में दर्शाता है, इसलिए स्थिति (x! = 4.0) कभी भी गलत नहीं होगी। इस समस्या का समाधान स्थिति को (k <= 4.0) के रूप में लिखना है। अनंत लूप समस्याओं का कारण बन सकते हैं यदि यह ठीक से नियंत्रित या डिज़ाइन नहीं किया जाता है, तो अत्यधिक सीपीयू संसाधन की खपत और कार्यक्रमों या प्रणालियों में गैर -जिम्मेदारता के लिए अग्रणी है। आवश्यक होने पर अनंत छोरों से बाहर निकलने के लिए तंत्र को लागू करना महत्वपूर्ण है। अनजाने में अनंत छोरों को रोकने के लिए लूप के भीतर निकास की स्थिति को शामिल करना उचित है। ये शर्तें उपयोगकर्ता इनपुट, विशिष्ट घटनाओं या झंडों या समय सीमा पर आधारित हो सकती हैं। लूप अपने उद्देश्य को पूरा करने या विशिष्ट मानदंडों को पूरा करने के बाद उचित निकास शर्तों को शामिल करके समाप्त हो जाएगा।

अनंत छोरों को रोकने के लिए तकनीक:

यद्यपि अनंत छोरों को कभी -कभी इरादा किया जा सकता है, वे अक्सर अनपेक्षित होते हैं और कार्यक्रम को फ्रीज या क्रैश का कारण बन सकते हैं। प्रोग्रामर अनजाने अनंत छोरों से बचने के लिए निम्नलिखित रणनीतियों का उपयोग कर सकते हैं: एक समाप्ति की स्थिति जोड़ें: सुनिश्चित करें कि लूप में एक ऐसी स्थिति है जो अंततः झूठे का मूल्यांकन कर सकती है, जिससे यह समाप्त हो सके। एक काउंटर को नियोजित करें: पुनरावृत्तियों की संख्या पर एक टोपी स्थापित करें और एक काउंटर को लागू करें जो प्रत्येक लूप पुनरावृत्ति के साथ बढ़ता है। इस प्रकार, भले ही आवश्यक स्थिति संतुष्ट नहीं है, लूप अंततः समाप्त हो जाएगा। एक टाइमआउट सिस्टम का परिचय दें: यदि समय सीमा तक पहुंच जाती है, तो लूप को रोक दिया जाएगा। उस समय की मात्रा को मापने के लिए टाइमर या सिस्टम फ़ंक्शंस का उपयोग करें। बाहरी या उपयोगकर्ता द्वारा प्रदान किए गए ट्रिगर का उपयोग करें: कुछ उपयोगकर्ता इनपुट या बाहर की घटनाओं के जवाब में समाप्त करने के लिए लूप डिजाइन करें। कुछ मामलों में, अनंत छोरों को जानबूझकर विशेष एल्गोरिदम या सिस्टम-स्तरीय संचालन में नियोजित किया जा सकता है। उदाहरण के लिए, रियल-टाइम सिस्टम या एम्बेडेड सिस्टम इनपुट की निगरानी करने या विशिष्ट कार्यों को लगातार निष्पादित करने के लिए अनंत छोरों का उपयोग करते हैं। हालांकि, सिस्टम के प्रदर्शन या जवाबदेही पर किसी भी प्रतिकूल प्रभाव से बचने के लिए, इस तरह के छोरों को ठीक से प्रबंधित करने के लिए देखभाल की जानी चाहिए। आधुनिक प्रोग्रामिंग भाषाएं और विकास ढांचे अक्सर अनंत छोरों को अधिक कुशलता से संभालने के लिए अंतर्निहित तंत्र प्रदान करते हैं। उदाहरण के लिए, ग्राफिकल यूजर इंटरफेस (GUI) फ्रेमवर्क इवेंट-संचालित आर्किटेक्चर प्रदान करते हैं, जहां प्रोग्राम उपयोगकर्ता इनपुट या सिस्टम इवेंट की प्रतीक्षा करते हैं, जो स्पष्ट अनंत छोरों की आवश्यकता को समाप्त करते हैं। अनंत छोरों का उपयोग करते समय सावधानी और विवेक का उपयोग करना आवश्यक है। उन्हें केवल तभी नियोजित किया जाना चाहिए जब अनिश्चितकालीन चल रहे लूप के लिए एक स्पष्ट और वैध कारण हो, और कार्यक्रम या प्रणाली पर किसी भी नकारात्मक प्रभाव को रोकने के लिए पर्याप्त सुरक्षा उपायों को लागू किया जाना चाहिए।

निष्कर्ष:

अंत में, C में एक अनंत लूप एक लूपिंग निर्माण का गठन करता है जो कभी खत्म नहीं होता है और हमेशा के लिए चलता रहता है। अलग-अलग लूप संरचनाएं, जैसे कि लूप के लिए, जबकि लूप, डो-व्हाइल लूप, गोटो स्टेटमेंट, या सी मैक्रोज़, इसका उत्पादन करने के लिए उपयोग किया जा सकता है। ऑपरेटिंग सिस्टम, सर्वर और वीडियो गेम सभी अक्सर अनंत छोरों को नियोजित करते हैं क्योंकि वे मैनुअल टर्मिनेशन तक निरंतर मानव इनपुट और आउटपुट की मांग करते हैं। दूसरी ओर, अनजाने अनंत छोरों को कोड की खामियों के कारण हो सकता है, जिन्हें पहचानना मुश्किल है, विशेष रूप से नए लोगों के लिए। अनजाने अनंत छोरों को रोकने के लिए अर्धविराम, तार्किक मानदंड और लूप समाप्ति आवश्यकताओं के सावधानीपूर्वक विचार की आवश्यकता है। अनंत छोरों के परिणामस्वरूप अनुचित अर्धविराम प्लेसमेंट या रिलेशनल ऑपरेटरों के स्थान पर असाइनमेंट ऑपरेटरों के उपयोग से हो सकता है। झूठी लूप की स्थिति जो हमेशा सच का मूल्यांकन करती है, इसी तरह एक अनंत लूप में परिणाम हो सकता है। इसके अलावा, चूंकि ब्रेक कीवर्ड केवल निकटतम लूप को समाप्त करता है, इसलिए नेस्टेड लूप में इसका उपयोग करते समय सावधानी का उपयोग किया जाना चाहिए। इसके अलावा, जैसा कि वे लूप समाप्ति की स्थिति को पूरा करने के लिए असंभव बना सकते हैं, फ्लोटिंग-पॉइंट नंबरों के साथ काम करते समय फ्लोटिंग-पॉइंट गलतियों पर विचार किया जाना चाहिए।